Okay let's restart. continuing

Okay, let's restart.

We were talking about constraint satisfaction problems,

and yesterday we kind of went into one of the techniques we have

four constraints that we were bike riding the Reンピ X pepper

for constraint satisfaction, for finding solutions.

I'd like to remind you,

the constraint satisfaction problem,

we kind of, from a general case,

we refined into constraint networks,

and constraint networks only have binary constraints.

That is sufficient, because we can kind of

stick the unary constraints into the domains,

and we can kind of encode higher constraints

to binary constraints.

So all we're left with is binary constraints.

The theory of those is relatively simple,

which is why we do it here.

In practice, you actually want to implement

special methods for higher constraints, at least,

because otherwise, with this encoding trick

that we're using, you lose quite a lot of structure.

And even imagine giving error messages

or something like this on an encoded problem

that the user has never seen.

Okay, so you want to do something practical,

you implement the whole thing.

But for the theory and the ideas,

it's sufficient to have binary constraints.

So what are we dealing with?

We have a set of n variables.

All of those have their own domain,

which might be different,

but all of which are finite for the time being.

And the third component is the constraints,

which are just relations between these domains.

And we only have one, so we have,

constraints are undirected.

Okay?

So, that's essentially what we're dealing with.

And all the ideas I'm showing you apply to these,

but can be transferred to higher arities as well.

Okay.

We looked at Sudoku, we looked at the constraints.

And why doesn't this work?

Okay, well.

And they're relatively easy to write,

and we can see already that, in this case,

we have inequality constraints in certain situations.

We developed a set of names for the things